import java.util.Arrays;
import java.util.Scanner;

public class Test6 {


    //改变原有数组元素的值
    // 方法1：可输入的数组变化
    public static void transform1(int[] array){    //定义将元素翻倍方法
        for(int i = 0; i < array.length; i++){
            array[i] *= 2;
        }
    }

    public static void main1(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("输入数组的长度:");
        int length = scanner.nextInt();           //将输入的值赋给length

        int[] array = new int[length];            //创建一个长度为 length 的整数数组 array
        System.out.println("请输入数组的值：");
        for(int i = 0; i < length; i++){          //for循环遍历数组
            array[i] = scanner.nextInt();         //将输入的值赋值给数组array
        }

        transform2(array);                        //调用方法
        System.out.println("数组元素翻倍后是：");

        for(int num : array){                     //遍历数组并将其打印
            System.out.print(num + " ");
        }
        scanner.close();
    }
    //方法2：不可输入的方法
    public static int[] transform2(int[] array){
        for(int i =0; i < array.length; i++){
            array[i] *= 2;
        }
        return array;
    }

    public static void main2(String[] args) {
        int[] array ={1,2,3};
        int[] doubleArray = transform2(array);
        System.out.println(Arrays.toString(doubleArray));
    }


    //给定一个有序整型数组, 实现二分查找
    public static void main3(String[] args) {
        int[] array = new int[]{1,2,3,4,5,6};
        int ret = Arrays.binarySearch(array,4);
        System.out.println("你要找的值位置在" + ret);
    }



    //调整数组顺序使得奇数位于偶数之前。调整之后，不关心大小顺序
    public static void main4(String[] args) {
        int[] array = {1,2,3,4,5,6};
        for(int x = 0; x < array.length-1; x++){
            for(int y = array.length-1; y > x; y--){
                if(array[y] % 2 != 0){
                    int tmp = array[y];
                    array[y] = array[x];
                    array[x] = tmp;
                }
            }
        }
        System.out.println(Arrays.toString(array));
    }

    //答案
    public static void func(int[] array) {
        int i = 0;
        int j = array.length - 1;

        while (i < j) {
            while (i<j && array[i] % 2 != 0) {
                i++;
            }
            while (i<j && array[j] % 2 == 0) {
                j--;
            }
            int tmp = array[i];
            array[i] = array[j];
            array[j] = tmp;
        }
    }

    public static void main5(String[] args) {
        int array[] = {1,2,3,4,5,6};
        func(array);
        System.out.println(Arrays.toString(array));
    }




    //冒泡排序(升序)
    public static void bubbleSort(int[] array){
        for(int i = 0; i < array.length; i++){
            for(int j = 0; j < i ; j++){
                if (array[i] < array[j]){
                    int tmp = array[j];
                    array[j] = array[i];
                    array[i] = tmp;
                }
            }
        }
    }

    public static void main6(String[] args) {
        int[] array = {7,2,8,4,9,6,1,5,3,0};
        bubbleSort(array);
        System.out.println(Arrays.toString(array));
    }

    //答案(空间优化，提前终止循环)
        public static void bubbleSortMax(int[] array) {                  // 定义一个静态方法 bubbleSort，用于对整数数组进行升序排序
            boolean swapped;                                          // 定义一个布尔变量 swapped，用于标记在一轮排序中是否发生了元素交换
            for (int i = 0; i < array.length; i++) {                  // 外层循环控制排序的轮数，最多进行 array.length - 1 轮
                swapped = false;                                      // 每一轮开始时，将 swapped 标记为 false，表示尚未发生交换
                for (int j = 0; j < array.length - 1 - i; j++) {      // 内层循环用于比较相邻元素并进行交换
                    if (array[j] > array[j + 1]) {                    // >为升序 <为降序
                        int tmp = array[j];                           // 定义一个临时变量 tmp，用于存储当前元素的值
                        array[j] = array[j + 1];
                        array[j + 1] = tmp;
                        swapped = true;                               // 发生了交换，将 swapped 标记为 true
                    }
                }
                if (!swapped) break;                                  // 如果在一轮排序中没有发生交换，说明数组已经有序，直接退出循环
            }
        }

        public static void main7(String[] args) {
            int[] array = {7, 2, 8, 4, 9, 6, 1, 5, 3, 0};
            bubbleSortMax(array);
            System.out.println(Arrays.toString(array));
        }




    //给定一个整数数组num和一个整数目标值 target 在该数组中找出和为目标值 target 的那两个整数，并返回它们的数组下标。
    public static int[] func(int[] array,int target)  {
        int[] ret = {-1,-1};
        for(int i=0; i<array.length; i++){
            for(int j=1; j<array.length; j++){
                if(array[i] + array[j] == target){
                    ret[0] = i;
                    ret[1] = j;
                    return ret;
                }
            }
        }
        return ret;
    }

    public static void main8(String[] args) {
        int[] array = {2,7,11,15};
        int[] ret = func(array,17);
        System.out.println(Arrays.toString(ret));
    }



    //给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。
    public static int func1(int[] array){
        int ret = 0;
        for(int i = 0; i<array.length; i++){  // 使用异或操作符（^）对数组中的每个元素进行异或操作
            ret ^= array[i];                  // 异或操作的特性是：相同的数异或结果为0，0与任何数异或结果为该数本身
        }
        return ret;
    }

    public static void main9(String[] args) {
        int[] array = {3,2,1,5,6,3,2,6,5};
        System.out.println(func1(array));
    }



    //给定一个大小为 n 的数组,找到其中的多数元素。多数元素是指在数组中出现次数大于 n/2 的元素。
    public static int func2(int[] array){
        Arrays.sort(array);
        return array[array.length/2];
    }

    public static void main10(String[] args) {
        int[] array = {2,2,1,1,1,2,2};
        System.out.println(func2(array));
    }



    //给你一个整数数组 arr，请你判断数组中是否存在连续三个元素都是奇数的情况：如果存在，请返回 true ；否则，返回 false
    public static boolean func3(int[] array) {
        boolean ret = false;
        int x = 0;                                    //计数
        for (int i = 0; i < array.length; i++) {      //循环判断
            if (array[i] % 2 != 0) {                  //判断是否为奇数
                x++;                                  //计算连续奇数个数
                if (x == 3) {                         //当连续3个时
                    ret = true;
                }
            }else{
                x = 0;
            }
        }
        return ret;                                   //返回布尔表达式
    }

    public static void main11(String[] args) {
        int[] array = {1,2,34,3,4,5,7,23,12};
        boolean ret = func3(array);
        System.out.println(ret);
    }
}
